home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / net / irda / irda_device.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  10.1 KB  |  288 lines
  1. /*********************************************************************
  2.  *                
  3.  * Filename:      irda_device.h
  4.  * Version:       0.9
  5.  * Description:   Contains various declarations used by the drivers
  6.  * Status:        Experimental.
  7.  * Author:        Dag Brattli <dagb@cs.uit.no>
  8.  * Created at:    Tue Apr 14 12:41:42 1998
  9.  * Modified at:   Mon Mar 20 09:08:57 2000
  10.  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11.  * 
  12.  *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
  13.  *     Copyright (c) 1998 Thomas Davis, <ratbert@radiks.net>,
  14.  *     Copyright (c) 2000-2002 Jean Tourrilhes <jt@hpl.hp.com>
  15.  *
  16.  *     This program is free software; you can redistribute it and/or 
  17.  *     modify it under the terms of the GNU General Public License as 
  18.  *     published by the Free Software Foundation; either version 2 of 
  19.  *     the License, or (at your option) any later version.
  20.  * 
  21.  *     This program is distributed in the hope that it will be useful,
  22.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  24.  *     GNU General Public License for more details.
  25.  * 
  26.  *     You should have received a copy of the GNU General Public License 
  27.  *     along with this program; if not, write to the Free Software 
  28.  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
  29.  *     MA 02111-1307 USA
  30.  *     
  31.  ********************************************************************/
  32.  
  33. /*
  34.  * This header contains all the IrDA definitions a driver really
  35.  * needs, and therefore the driver should not need to include
  36.  * any other IrDA headers - Jean II
  37.  */
  38.  
  39. #ifndef IRDA_DEVICE_H
  40. #define IRDA_DEVICE_H
  41.  
  42. #include <linux/tty.h>
  43. #include <linux/netdevice.h>
  44. #include <linux/spinlock.h>
  45. #include <linux/skbuff.h>        /* struct sk_buff */
  46. #include <linux/irda.h>
  47. #include <linux/types.h>
  48.  
  49. #include <net/pkt_sched.h>
  50. #include <net/irda/irda.h>
  51. #include <net/irda/qos.h>        /* struct qos_info */
  52. #include <net/irda/irqueue.h>        /* irda_queue_t */
  53.  
  54. /* A few forward declarations (to make compiler happy) */
  55. struct irlap_cb;
  56.  
  57. /* Some non-standard interface flags (should not conflict with any in if.h) */
  58. #define IFF_SIR     0x0001 /* Supports SIR speeds */
  59. #define IFF_MIR     0x0002 /* Supports MIR speeds */
  60. #define IFF_FIR     0x0004 /* Supports FIR speeds */
  61. #define IFF_VFIR        0x0008 /* Supports VFIR speeds */
  62. #define IFF_PIO       0x0010 /* Supports PIO transfer of data */
  63. #define IFF_DMA        0x0020 /* Supports DMA transfer of data */
  64. #define IFF_SHM         0x0040 /* Supports shared memory data transfers */
  65. #define IFF_DONGLE      0x0080 /* Interface has a dongle attached */
  66. #define IFF_AIR         0x0100 /* Supports Advanced IR (AIR) standards */
  67.  
  68. #define IO_XMIT 0x01
  69. #define IO_RECV 0x02
  70.  
  71. typedef enum {
  72.     IRDA_IRLAP, /* IrDA mode, and deliver to IrLAP */
  73.     IRDA_RAW,   /* IrDA mode */
  74.     SHARP_ASK,
  75.     TV_REMOTE,  /* Also known as Consumer Electronics IR */
  76. } INFRARED_MODE;
  77.  
  78. typedef enum {
  79.     IRDA_TASK_INIT,        /* All tasks are initialized with this state */
  80.     IRDA_TASK_DONE,        /* Signals that the task is finished */
  81.     IRDA_TASK_WAIT,
  82.     IRDA_TASK_WAIT1,
  83.     IRDA_TASK_WAIT2,
  84.     IRDA_TASK_WAIT3,
  85.     IRDA_TASK_CHILD_INIT,  /* Initializing child task */
  86.     IRDA_TASK_CHILD_WAIT,  /* Waiting for child task to finish */
  87.     IRDA_TASK_CHILD_DONE   /* Child task is finished */
  88. } IRDA_TASK_STATE;
  89.  
  90. struct irda_task;
  91. typedef int (*IRDA_TASK_CALLBACK) (struct irda_task *task);
  92.  
  93. struct irda_task {
  94.     irda_queue_t q;
  95.     magic_t magic;
  96.  
  97.     IRDA_TASK_STATE state;
  98.     IRDA_TASK_CALLBACK function;
  99.     IRDA_TASK_CALLBACK finished;
  100.  
  101.     struct irda_task *parent;
  102.     struct timer_list timer;
  103.  
  104.     void *instance; /* Instance being called */
  105.     void *param;    /* Parameter to be used by instance */
  106. };
  107.  
  108. /* Dongle info */
  109. struct dongle_reg;
  110. typedef struct {
  111.     struct dongle_reg *issue;     /* Registration info */
  112.     struct net_device *dev;           /* Device we are attached to */
  113.     struct irda_task *speed_task; /* Task handling speed change */
  114.     struct irda_task *reset_task; /* Task handling reset */
  115.     __u32 speed;                  /* Current speed */
  116.  
  117.     /* Callbacks to the IrDA device driver */
  118.     int (*set_mode)(struct net_device *, int mode);
  119.     int (*read)(struct net_device *dev, __u8 *buf, int len);
  120.     int (*write)(struct net_device *dev, __u8 *buf, int len);
  121.     int (*set_dtr_rts)(struct net_device *dev, int dtr, int rts);
  122. } dongle_t;
  123.  
  124. /* Dongle registration info */
  125. struct dongle_reg {
  126.     irda_queue_t q;         /* Must be first */
  127.     IRDA_DONGLE type;
  128.  
  129.     void (*open)(dongle_t *dongle, struct qos_info *qos);
  130.     void (*close)(dongle_t *dongle);
  131.     int  (*reset)(struct irda_task *task);
  132.     int  (*change_speed)(struct irda_task *task);
  133.     struct module *owner;
  134. };
  135.  
  136. /* 
  137.  * Per-packet information we need to hide inside sk_buff 
  138.  * (must not exceed 48 bytes, check with struct sk_buff)
  139.  * The default_qdisc_pad field is a temporary hack.
  140.  */
  141. struct irda_skb_cb {
  142.     unsigned int default_qdisc_pad;
  143.     magic_t magic;       /* Be sure that we can trust the information */
  144.     __u32   next_speed;  /* The Speed to be set *after* this frame */
  145.     __u16   mtt;         /* Minimum turn around time */
  146.     __u16   xbofs;       /* Number of xbofs required, used by SIR mode */
  147.     __u16   next_xbofs;  /* Number of xbofs required *after* this frame */
  148.     void    *context;    /* May be used by drivers */
  149.     void    (*destructor)(struct sk_buff *skb); /* Used for flow control */
  150.     __u16   xbofs_delay; /* Number of xbofs used for generating the mtt */
  151.     __u8    line;        /* Used by IrCOMM in IrLPT mode */
  152. };
  153.  
  154. /* Chip specific info */
  155. typedef struct {
  156.     int cfg_base;         /* Config register IO base */
  157.         int sir_base;         /* SIR IO base */
  158.     int fir_base;         /* FIR IO base */
  159.     int mem_base;         /* Shared memory base */
  160.         int sir_ext;          /* Length of SIR iobase */
  161.     int fir_ext;          /* Length of FIR iobase */
  162.         int irq, irq2;        /* Interrupts used */
  163.         int dma, dma2;        /* DMA channel(s) used */
  164.         int fifo_size;        /* FIFO size */
  165.         int irqflags;         /* interrupt flags (ie, IRQF_SHARED|IRQF_DISABLED) */
  166.     int direction;        /* Link direction, used by some FIR drivers */
  167.     int enabled;          /* Powered on? */
  168.     int suspended;        /* Suspended by APM */
  169.     __u32 speed;          /* Currently used speed */
  170.     __u32 new_speed;      /* Speed we must change to when Tx is finished */
  171.     int dongle_id;        /* Dongle or transceiver currently used */
  172. } chipio_t;
  173.  
  174. /* IO buffer specific info (inspired by struct sk_buff) */
  175. typedef struct {
  176.     int state;            /* Receiving state (transmit state not used) */
  177.     int in_frame;         /* True if receiving frame */
  178.  
  179.     __u8 *head;          /* start of buffer */
  180.     __u8 *data;          /* start of data in buffer */
  181.  
  182.     int len;          /* current length of data */
  183.     int truesize;          /* total allocated size of buffer */
  184.     __u16 fcs;
  185.  
  186.     struct sk_buff *skb;    /* ZeroCopy Rx in async_unwrap_char() */
  187. } iobuff_t;
  188.  
  189. /* Maximum SIR frame (skb) that we expect to receive *unwrapped*.
  190.  * Max LAP MTU (I field) is 2048 bytes max (IrLAP 1.1, chapt 6.6.5, p40).
  191.  * Max LAP header is 2 bytes (for now).
  192.  * Max CRC is 2 bytes at SIR, 4 bytes at FIR. 
  193.  * Need 1 byte for skb_reserve() to align IP header for IrLAN.
  194.  * Add a few extra bytes just to be safe (buffer is power of two anyway)
  195.  * Jean II */
  196. #define IRDA_SKB_MAX_MTU    2064
  197. /* Maximum SIR frame that we expect to send, wrapped (i.e. with XBOFS
  198.  * and escaped characters on top of above). */
  199. #define IRDA_SIR_MAX_FRAME    4269
  200.  
  201. /* The SIR unwrapper async_unwrap_char() will use a Rx-copy-break mechanism
  202.  * when using the optional ZeroCopy Rx, where only small frames are memcpy
  203.  * to a smaller skb to save memory. This is the threshold under which copy
  204.  * will happen (and over which it won't happen).
  205.  * Some FIR drivers may use this #define as well...
  206.  * This is the same value as various Ethernet drivers. - Jean II */
  207. #define IRDA_RX_COPY_THRESHOLD  256
  208.  
  209. /* Function prototypes */
  210. int  irda_device_init(void);
  211. void irda_device_cleanup(void);
  212.  
  213. /* IrLAP entry points used by the drivers.
  214.  * We declare them here to avoid the driver pulling a whole bunch stack
  215.  * headers they don't really need - Jean II */
  216. struct irlap_cb *irlap_open(struct net_device *dev, struct qos_info *qos,
  217.                 const char *hw_name);
  218. void irlap_close(struct irlap_cb *self);
  219.  
  220. /* Interface to be uses by IrLAP */
  221. void irda_device_set_media_busy(struct net_device *dev, int status);
  222. int  irda_device_is_media_busy(struct net_device *dev);
  223. int  irda_device_is_receiving(struct net_device *dev);
  224.  
  225. /* Interface for internal use */
  226. static inline int irda_device_txqueue_empty(const struct net_device *dev)
  227. {
  228.     return qdisc_all_tx_empty(dev);
  229. }
  230. int  irda_device_set_raw_mode(struct net_device* self, int status);
  231. struct net_device *alloc_irdadev(int sizeof_priv);
  232.  
  233. void irda_setup_dma(int channel, dma_addr_t buffer, int count, int mode);
  234.  
  235. /*
  236.  * Function irda_get_mtt (skb)
  237.  *
  238.  *    Utility function for getting the minimum turnaround time out of 
  239.  *    the skb, where it has been hidden in the cb field.
  240.  */
  241. static inline __u16 irda_get_mtt(const struct sk_buff *skb)
  242. {
  243.     const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb;
  244.     return (cb->magic == LAP_MAGIC) ? cb->mtt : 10000;
  245. }
  246.  
  247. /*
  248.  * Function irda_get_next_speed (skb)
  249.  *
  250.  *    Extract the speed that should be set *after* this frame from the skb
  251.  *
  252.  * Note : return -1 for user space frames
  253.  */
  254. static inline __u32 irda_get_next_speed(const struct sk_buff *skb)
  255. {
  256.     const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb;
  257.     return (cb->magic == LAP_MAGIC) ? cb->next_speed : -1;
  258. }
  259.  
  260. /*
  261.  * Function irda_get_next_xbofs (skb)
  262.  *
  263.  *    Extract the xbofs that should be set for this frame from the skb
  264.  *
  265.  * Note : default to 10 for user space frames
  266.  */
  267. static inline __u16 irda_get_xbofs(const struct sk_buff *skb)
  268. {
  269.     const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb;
  270.     return (cb->magic == LAP_MAGIC) ? cb->xbofs : 10;
  271. }
  272.  
  273. /*
  274.  * Function irda_get_next_xbofs (skb)
  275.  *
  276.  *    Extract the xbofs that should be set *after* this frame from the skb
  277.  *
  278.  * Note : return -1 for user space frames
  279.  */
  280. static inline __u16 irda_get_next_xbofs(const struct sk_buff *skb)
  281. {
  282.     const struct irda_skb_cb *cb = (const struct irda_skb_cb *) skb->cb;
  283.     return (cb->magic == LAP_MAGIC) ? cb->next_xbofs : -1;
  284. }
  285. #endif /* IRDA_DEVICE_H */
  286.  
  287.  
  288.